home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cocktail / lalr.lha / lalr / m2c / Gen.c < prev    next >
C/C++ Source or Header  |  1992-08-18  |  29KB  |  1,187 lines
  1. #include "SYSTEM_.h"
  2.  
  3. #ifndef DEFINITION_Actions
  4. #include "Actions.h"
  5. #endif
  6.  
  7. #ifndef DEFINITION_ArgCheck
  8. #include "ArgCheck.h"
  9. #endif
  10.  
  11. #ifndef DEFINITION_Automaton
  12. #include "Automaton.h"
  13. #endif
  14.  
  15. #ifndef DEFINITION_Compress
  16. #include "Compress.h"
  17. #endif
  18.  
  19. #ifndef DEFINITION_Continue
  20. #include "Continue.h"
  21. #endif
  22.  
  23. #ifndef DEFINITION_Checks
  24. #include "Checks.h"
  25. #endif
  26.  
  27. #ifndef DEFINITION_Default
  28. #include "Default.h"
  29. #endif
  30.  
  31. #ifndef DEFINITION_DynArray
  32. #include "DynArray.h"
  33. #endif
  34.  
  35. #ifndef DEFINITION_Errors
  36. #include "Errors.h"
  37. #endif
  38.  
  39. #ifndef DEFINITION_Final
  40. #include "Final.h"
  41. #endif
  42.  
  43. #ifndef DEFINITION_General
  44. #include "General.h"
  45. #endif
  46.  
  47. #ifndef DEFINITION_GenLang
  48. #include "GenLang.h"
  49. #endif
  50.  
  51. #ifndef DEFINITION_IO
  52. #include "IO.h"
  53. #endif
  54.  
  55. #ifndef DEFINITION_Lists
  56. #include "Lists.h"
  57. #endif
  58.  
  59. #ifndef DEFINITION_Lists
  60. #include "Lists.h"
  61. #endif
  62.  
  63. #ifndef DEFINITION_Sets
  64. #include "Sets.h"
  65. #endif
  66.  
  67. #ifndef DEFINITION_Strings
  68. #include "Strings.h"
  69. #endif
  70.  
  71. #ifndef DEFINITION_StringMem
  72. #include "StringMem.h"
  73. #endif
  74.  
  75. #ifndef DEFINITION_Strings
  76. #include "Strings.h"
  77. #endif
  78.  
  79. #ifndef DEFINITION_Idents
  80. #include "Idents.h"
  81. #endif
  82.  
  83. #ifndef DEFINITION_SysError
  84. #include "SysError.h"
  85. #endif
  86.  
  87. #ifndef DEFINITION_System
  88. #include "System.h"
  89. #endif
  90.  
  91. #ifndef DEFINITION_System
  92. #include "System.h"
  93. #endif
  94.  
  95. #ifndef DEFINITION_Times
  96. #include "Times.h"
  97. #endif
  98.  
  99. #ifndef DEFINITION_TokenTab
  100. #include "TokenTab.h"
  101. #endif
  102.  
  103. #ifndef DEFINITION_WriteTok
  104. #include "WriteTok.h"
  105. #endif
  106.  
  107. #ifndef DEFINITION_Gen
  108. #include "Gen.h"
  109. #endif
  110.  
  111. BOOLEAN Gen_Trace;
  112. BOOLEAN Gen_CaseFlag;
  113. INTEGER Gen_CaseLabels;
  114. TokenTab_Vocabulary Gen_FirstSymbol, Gen_LastSymbol, Gen_FirstTerminal, Gen_LastTerminal;
  115. CARDINAL Gen_NonTermOffset;
  116. Automaton_tStateIndex Gen_FirstState, Gen_LastState, Gen_FirstReadState, Gen_LastReadState, Gen_FirstReadTermState, Gen_LastReadTermState, Gen_FirstReadNonTermState, Gen_LastReadNonTermState, Gen_FirstReduceState, Gen_LastReduceState, Gen_StopState;
  117. Automaton_tStateIndex Gen_ReduceOffset;
  118. Gen_TableElmt Gen_ElmtSize;
  119. struct Gen_2 *Gen_Length;
  120. LONGINT Gen_LengthCount;
  121. struct Gen_3 *Gen_LeftHandSide;
  122. LONGINT Gen_LeftHandSideCount;
  123. struct Gen_4 *Gen_Continuation;
  124. LONGINT Gen_ContinuationCount;
  125. struct Gen_5 *Gen_FinalToProd;
  126. LONGINT Gen_FinalToProdCount;
  127.  
  128. #define EOL    '\n'
  129. #define InitReduceCount    4
  130. typedef struct S_1 {
  131.     Gen_TableElmt Check, Next;
  132. } ControlType;
  133. static Gen_tTableLine TableLine;
  134. static Automaton_tStateIndex StateCnt;
  135. static struct S_2 {
  136.     CHAR A[128 + 1];
  137. } FileName;
  138. static void FindKind ARGS(());
  139. static void MakeNumbers ARGS(());
  140. static void MakeTable ARGS(());
  141. static void InitTableLine ARGS(());
  142. static Automaton_tStateIndex MakeTableLine ARGS((Automaton_tStateIndex state));
  143. static void MakeLength ARGS(());
  144. static void MakeLeftHandSide ARGS(());
  145. static TokenTab_Vocabulary FindFirstTerminal ARGS(());
  146. static TokenTab_Vocabulary FindLastTerminal ARGS(());
  147. static TokenTab_Vocabulary FindLastSymbol ARGS(());
  148. static void PrepareReduceCode ARGS(());
  149. static void PutTables ARGS((System_tFile TableFile));
  150. static void PutTable ARGS((Gen_TableElmt Length, ADDRESS Address));
  151. static void PutBase ARGS((System_tFile File));
  152. static void PutNBase ARGS((System_tFile File));
  153. static void PutDefault ARGS((System_tFile File));
  154. static void PutControl ARGS((System_tFile File));
  155. static void PutNNext ARGS((System_tFile File));
  156. static void PutLength ARGS((System_tFile File));
  157. static void PutLeftHandSide ARGS((System_tFile File));
  158. static void PutContinuation ARGS((System_tFile File));
  159. static void PutFinalToProd ARGS((System_tFile File));
  160.  
  161. static BOOLEAN *G_1_InError;
  162. static System_tFile *G_2_TableFile;
  163.  
  164. void Gen_GenDefaultActions
  165. # ifdef __STDC__
  166. ()
  167. # else
  168. ()
  169. # endif
  170. {
  171.   Lists_tList act;
  172.   TokenTab_PosType pos;
  173.   Lists_tList com;
  174.   TokenTab_PosType cpos;
  175.   Strings_tString s;
  176.  
  177.   Lists_MakeList(&act);
  178.   pos.Line = 0;
  179.   pos.Column = 0;
  180.   Lists_MakeList(&com);
  181.   cpos.Line = 0;
  182.   cpos.Column = 0;
  183.   if (WriteTok_Language == WriteTok_Modula2) {
  184.     Strings_ArrayToString((STRING)"{", 1L, &s);
  185.     Strings_Append(&s, EOL);
  186.     Lists_Append(&act, (ADDRESS)StringMem_PutString(&s));
  187.     Strings_ArrayToString((STRING)"TYPE", 4L, &s);
  188.     Strings_Append(&s, EOL);
  189.     Lists_Append(&act, (ADDRESS)StringMem_PutString(&s));
  190.     Strings_ArrayToString((STRING)"   tParsAttribute = RECORD", 26L, &s);
  191.     Strings_Append(&s, EOL);
  192.     Lists_Append(&act, (ADDRESS)StringMem_PutString(&s));
  193.     Strings_ArrayToString((STRING)"                       Scan: Scanner.tScanAttribute", 51L, &s);
  194.     Strings_Append(&s, EOL);
  195.     Lists_Append(&act, (ADDRESS)StringMem_PutString(&s));
  196.     Strings_ArrayToString((STRING)"                    END;", 24L, &s);
  197.     Strings_Append(&s, EOL);
  198.     Lists_Append(&act, (ADDRESS)StringMem_PutString(&s));
  199.     Strings_ArrayToString((STRING)"}", 1L, &s);
  200.     Lists_Append(&act, (ADDRESS)StringMem_PutString(&s));
  201.   } else {
  202.     Strings_ArrayToString((STRING)"{", 1L, &s);
  203.     Strings_Append(&s, EOL);
  204.     Lists_Append(&act, (ADDRESS)StringMem_PutString(&s));
  205.     Strings_ArrayToString((STRING)"typedef struct    { tScanAttribute Scan; } tParsAttribute;", 58L, &s);
  206.     Strings_Append(&s, EOL);
  207.     Lists_Append(&act, (ADDRESS)StringMem_PutString(&s));
  208.     Strings_ArrayToString((STRING)"}", 1L, &s);
  209.     Lists_Append(&act, (ADDRESS)StringMem_PutString(&s));
  210.   }
  211.   Actions_PutAction(Actions_Global, act, pos, com, cpos);
  212. }
  213.  
  214. void Gen_GenCode
  215. # ifdef __STDC__
  216. (System_tFile Pars, System_tFile Def)
  217. # else
  218. (Pars, Def)
  219. System_tFile Pars;
  220. System_tFile Def;
  221. # endif
  222. {
  223.   System_tFile out;
  224.   Strings_tString C_1_line, rest, String1, String2;
  225.   INTEGER N;
  226.  
  227.   FindKind();
  228.   MakeNumbers();
  229.   MakeLength();
  230.   MakeLeftHandSide();
  231.   Continue_MakeContinuation();
  232.   Final_MakeFinalToProd();
  233.   if (Gen_Trace) {
  234.     IO_WriteS((System_tFile)IO_StdOutput, (STRING)" Time :", 7L);
  235.     IO_WriteI((System_tFile)IO_StdOutput, Times_StepTime(), 5L);
  236.     IO_WriteNl((System_tFile)IO_StdOutput);
  237.   }
  238.   MakeTable();
  239.   if (Gen_Trace) {
  240.     IO_WriteS((System_tFile)IO_StdOutput, (STRING)" Time :", 7L);
  241.     IO_WriteI((System_tFile)IO_StdOutput, Times_StepTime(), 5L);
  242.     IO_WriteNl((System_tFile)IO_StdOutput);
  243.   }
  244.   INC1(Compress_TableSize, Gen_LastTerminal);
  245.   INC1(Compress_NTableSize, Gen_LastSymbol);
  246.   if (WriteTok_Language == WriteTok_Modula2) {
  247.     ArgCheck_MakeFileName(Actions_ParserName, ArgCheck_Parser, 6L, (STRING)".Tab", 4L, FileName.A, 129L);
  248.     out = OpenOutput(FileName.A, 129L);
  249.     if (SysError_StatIsBad(out)) {
  250.       Strings_ArrayToString(FileName.A, 129L, &String1);
  251.       SysError_SysErrorMessageI(out, (LONGCARD)Errors_eError, (LONGCARD)Errors_eString, ADR(String1));
  252.     } else {
  253.       PutTables(out);
  254.       Close(out);
  255.     }
  256.   }
  257.   ArgCheck_MakeFileName(Actions_ParserName, ArgCheck_Parser, 6L, ArgCheck_ExtImp.A, 6L, FileName.A, 129L);
  258.   out = IO_WriteOpen(FileName.A, 129L);
  259.   Checks_CheckWriteOpen(&out, FileName.A, 129L);
  260.   while (!IO_EndOfFile(Pars)) {
  261.     Strings_ReadL(Pars, &C_1_line);
  262.     if (Strings_Length(&C_1_line) >= 2 && Strings_Char(&C_1_line, 1) == '$') {
  263.       switch (Strings_Char(&C_1_line, 2)) {
  264.       case 'G':;
  265.         Actions_WriteActions(Actions_Global, out, ArgCheck_LineFlag);
  266.         break;
  267.       case 'T':;
  268.         GenLang_WriteConstants(out);
  269.         break;
  270.       case 'L':;
  271.         Actions_WriteActions(Actions_Local, out, ArgCheck_LineFlag);
  272.         break;
  273.       case 'R':;
  274.         PrepareReduceCode();
  275.         GenLang_WriteReduceCode(out);
  276.         break;
  277.       case 'B':;
  278.         Actions_WriteActions(Actions_Begin, out, ArgCheck_LineFlag);
  279.         break;
  280.       case 'C':;
  281.         Actions_WriteActions(Actions_Close, out, ArgCheck_LineFlag);
  282.         break;
  283.       case 'X':;
  284.         if (Gen_CaseFlag) {
  285.           Strings_SubString(&C_1_line, 3, (Strings_tStringIndex)Strings_Length(&C_1_line), &rest);
  286.           Strings_WriteL(out, &rest);
  287.         }
  288.         break;
  289.       case 'W':;
  290.         WriteTok_GenWrTo(out);
  291.         break;
  292.       case 'P':;
  293.         PutBase(out);
  294.         break;
  295.       case 'Q':;
  296.         PutNBase(out);
  297.         break;
  298.       case 'D':;
  299.         PutDefault(out);
  300.         break;
  301.       case 'M':;
  302.         PutControl(out);
  303.         break;
  304.       case 'N':;
  305.         PutNNext(out);
  306.         break;
  307.       case 'K':;
  308.         PutLength(out);
  309.         break;
  310.       case 'H':;
  311.         PutLeftHandSide(out);
  312.         break;
  313.       case 'O':;
  314.         PutContinuation(out);
  315.         break;
  316.       case 'F':;
  317.         PutFinalToProd(out);
  318.         break;
  319.       case '@':;
  320.         ArgCheck_ExpandLine(out, C_1_line);
  321.         break;
  322.       }
  323.     } else {
  324.       Strings_WriteL(out, &C_1_line);
  325.     }
  326.   }
  327.   IO_WriteClose(out);
  328.   if (!IO_EndOfFile(Def)) {
  329.     ArgCheck_MakeFileName(Actions_ParserName, ArgCheck_Parser, 6L, ArgCheck_ExtDef.A, 6L, FileName.A, 129L);
  330.     out = IO_WriteOpen(FileName.A, 129L);
  331.     Checks_CheckWriteOpen(&out, FileName.A, 129L);
  332.     while (!IO_EndOfFile(Def)) {
  333.       Strings_ReadL(Def, &C_1_line);
  334.       if (Strings_Length(&C_1_line) >= 2 && Strings_Char(&C_1_line, 1) == '$') {
  335.         switch (Strings_Char(&C_1_line, 2)) {
  336.         case 'E':;
  337.           Actions_WriteActions(Actions_Export, out, ArgCheck_LineFlag);
  338.           break;
  339.         case '@':;
  340.           ArgCheck_ExpandLine(out, C_1_line);
  341.           break;
  342.         }
  343.       } else {
  344.         Strings_WriteL(out, &C_1_line);
  345.       }
  346.     }
  347.     IO_WriteClose(out);
  348.   }
  349. }
  350.  
  351. static void FindKind
  352. # ifdef __STDC__
  353. ()
  354. # else
  355. ()
  356. # endif
  357. {
  358.   Automaton_tStateIndex maxState, state;
  359.   Automaton_tProduction prod;
  360.   Automaton_tItemIndex item;
  361.   CARDINAL RepCount;
  362.   Automaton_tItemIndex LastItem;
  363.  
  364.   maxState = Automaton_StateIndex;
  365.   {
  366.     Automaton_tStateIndex B_1 = 1, B_2 = maxState;
  367.  
  368.     if (B_1 <= B_2)
  369.       for (state = B_1;; state += 1) {
  370.         {
  371.           register Automaton_tState *W_1 = &Automaton_StateArrayPtr->A[state - 1];
  372.  
  373.           if (W_1->Size == 1) {
  374.             RepCount = 1;
  375.             item = W_1->Items;
  376.           } else {
  377.             RepCount = 0;
  378.             {
  379.               LONGCARD B_3 = W_1->Items, B_4 = W_1->Items + W_1->Size - 1;
  380.  
  381.               if (B_3 <= B_4)
  382.                 for (item = B_3;; item += 1) {
  383.                   {
  384.                     register Automaton_tItem *W_2 = &Automaton_ItemArrayPtr->A[item - 1];
  385.  
  386.                     if (W_2->Rep != Automaton_NoRep) {
  387.                       INC(RepCount);
  388.                       LastItem = item;
  389.                     }
  390.                   }
  391.                   if (item >= B_4) break;
  392.                 }
  393.             }
  394.             item = LastItem;
  395.           }
  396.           if (RepCount == 1) {
  397.             {
  398.               register Automaton_tItem *W_3 = &Automaton_ItemArrayPtr->A[item - 1];
  399.  
  400.               if (W_3->Rep == Automaton_RedRep) {
  401.                 prod = (Automaton_tProduction)ADR(Automaton_ProdArrayPtr->A[W_3->Prod]);
  402.                 {
  403.                   register struct Automaton_9 *W_4 = prod;
  404.  
  405.                   if (W_4->Right.A[W_4->Len - 1] > TokenTab_MAXTerm) {
  406.                     W_1->Kind = Automaton_sNonterm;
  407.                   } else {
  408.                     W_1->Kind = Automaton_sTerm;
  409.                   }
  410.                 }
  411.               } else {
  412.                 W_1->Kind = Automaton_sRead;
  413.               }
  414.             }
  415.           } else {
  416.             W_1->Kind = Automaton_sRead;
  417.           }
  418.         }
  419.         if (state >= B_2) break;
  420.       }
  421.   }
  422. }
  423.  
  424. static void MakeNumbers
  425. # ifdef __STDC__
  426. ()
  427. # else
  428. ()
  429. # endif
  430. {
  431.   Automaton_tStateIndex maxState, state;
  432.   Automaton_tProduction prod;
  433.   Automaton_tStateIndex remember;
  434.  
  435.   Gen_FirstTerminal = FindFirstTerminal();
  436.   Gen_LastTerminal = FindLastTerminal();
  437.   Gen_NonTermOffset = TokenTab_MINNonTerm - Gen_LastTerminal - 1;
  438.   Gen_FirstSymbol = Gen_FirstTerminal;
  439.   Gen_LastSymbol = FindLastSymbol() - Gen_NonTermOffset;
  440.   StateCnt = 0;
  441.   maxState = Automaton_StateIndex;
  442.   Gen_FirstState = 1;
  443.   Gen_FirstReadState = StateCnt + 1;
  444.   {
  445.     Automaton_tStateIndex B_5 = 1, B_6 = maxState;
  446.  
  447.     if (B_5 <= B_6)
  448.       for (state = B_5;; state += 1) {
  449.         {
  450.           register Automaton_tState *W_5 = &Automaton_StateArrayPtr->A[state - 1];
  451.  
  452.           if (W_5->Kind == Automaton_sRead) {
  453.             INC(StateCnt);
  454.             W_5->NewNumber = StateCnt;
  455.           }
  456.         }
  457.         if (state >= B_6) break;
  458.       }
  459.   }
  460.   Gen_LastReadState = StateCnt;
  461.   Gen_FirstReadTermState = StateCnt + 1;
  462.   {
  463.     Automaton_tStateIndex B_7 = 1, B_8 = maxState;
  464.  
  465.     if (B_7 <= B_8)
  466.       for (state = B_7;; state += 1) {
  467.         {
  468.           register Automaton_tState *W_6 = &Automaton_StateArrayPtr->A[state - 1];
  469.  
  470.           if (W_6->Kind == Automaton_sTerm) {
  471.             prod = (Automaton_tProduction)ADR(Automaton_ProdArrayPtr->A[Automaton_ItemArrayPtr->A[W_6->Items - 1].Prod]);
  472.             if (prod->Left == Automaton_StartSymbol) {
  473.               remember = state;
  474.             } else {
  475.               INC(StateCnt);
  476.               W_6->NewNumber = StateCnt;
  477.             }
  478.           }
  479.         }
  480.         if (state >= B_8) break;
  481.       }
  482.   }
  483.   Gen_LastReadTermState = StateCnt;
  484.   Gen_FirstReadNonTermState = StateCnt + 1;
  485.   {
  486.     Automaton_tStateIndex B_9 = 1, B_10 = maxState;
  487.  
  488.     if (B_9 <= B_10)
  489.       for (state = B_9;; state += 1) {
  490.         {
  491.           register Automaton_tState *W_7 = &Automaton_StateArrayPtr->A[state - 1];
  492.  
  493.           if (W_7->Kind == Automaton_sNonterm) {
  494.             INC(StateCnt);
  495.             W_7->NewNumber = StateCnt;
  496.           }
  497.         }
  498.         if (state >= B_10) break;
  499.       }
  500.   }
  501.   Gen_LastReadNonTermState = StateCnt;
  502.   Gen_ReduceOffset = StateCnt;
  503.   {
  504.     register Automaton_tState *W_8 = &Automaton_StateArrayPtr->A[remember - 1];
  505.  
  506.     prod = (Automaton_tProduction)ADR(Automaton_ProdArrayPtr->A[Automaton_ItemArrayPtr->A[W_8->Items - 1].Prod]);
  507.     W_8->NewNumber = prod->ProdNo + Gen_ReduceOffset;
  508.   }
  509.   Gen_FirstReduceState = StateCnt + 1;
  510.   Gen_LastReduceState = Gen_ReduceOffset + Automaton_ProdCount;
  511.   Gen_StopState = Gen_FirstReduceState;
  512.   Gen_LastState = Gen_LastReduceState;
  513. }
  514.  
  515. static void MakeTable
  516. # ifdef __STDC__
  517. ()
  518. # else
  519. ()
  520. # endif
  521. {
  522.   Automaton_tStateIndex maxState;
  523.   Automaton_tStateIndex state;
  524.   Automaton_tStateIndex index;
  525.   Automaton_tStateIndex NewNum;
  526.   Automaton_tStateIndex DefaultState;
  527.  
  528.   Default_CreateDefaultList();
  529.   maxState = Automaton_StateIndex;
  530.   {
  531.     Automaton_tStateIndex B_11 = 1, B_12 = maxState;
  532.  
  533.     if (B_11 <= B_12)
  534.       for (state = B_11;; state += 1) {
  535.         InitTableLine();
  536.         NewNum = MakeTableLine(state);
  537.         if (NewNum <= Gen_LastReadState) {
  538.           Default_PutInDefaultList(NewNum, &TableLine);
  539.         }
  540.         if (state >= B_12) break;
  541.       }
  542.   }
  543.   Default_ComputeDefaults();
  544.   Compress_InitCompressTable();
  545.   {
  546.     Automaton_tStateIndex B_13 = 1, B_14 = Gen_LastReadState;
  547.  
  548.     if (B_13 <= B_14)
  549.       for (index = B_13;; index += 1) {
  550.         NewNum = Default_GetTSortState(index);
  551.         Default_GetDefaultTableLine(NewNum, &TableLine, &DefaultState);
  552.         Compress_CompressTableLine(NewNum, DefaultState, &TableLine);
  553.         if (index >= B_14) break;
  554.       }
  555.   }
  556.   Compress_InitCompressNTable();
  557.   {
  558.     Automaton_tStateIndex B_15 = 1, B_16 = Gen_LastReadState;
  559.  
  560.     if (B_15 <= B_16)
  561.       for (index = B_15;; index += 1) {
  562.         NewNum = Default_GetNSortState(index);
  563.         Default_GetDefaultTableLine(NewNum, &TableLine, &DefaultState);
  564.         Compress_CompressNTableLine(NewNum, &TableLine);
  565.         if (index >= B_16) break;
  566.       }
  567.   }
  568. }
  569.  
  570. static void InitTableLine
  571. # ifdef __STDC__
  572. ()
  573. # else
  574. ()
  575. # endif
  576. {
  577.   Automaton_tStateIndex state;
  578.   TokenTab_Vocabulary symbol;
  579.  
  580.   {
  581.     TokenTab_Vocabulary B_17 = Gen_FirstSymbol, B_18 = Gen_LastSymbol;
  582.  
  583.     if (B_17 <= B_18)
  584.       for (symbol = B_17;; symbol += 1) {
  585.         TableLine.A[symbol] = Gen_NoState;
  586.         if (symbol >= B_18) break;
  587.       }
  588.   }
  589. }
  590.  
  591. static Automaton_tStateIndex MakeTableLine
  592. # ifdef __STDC__
  593. (Automaton_tStateIndex state)
  594. # else
  595. (state)
  596. Automaton_tStateIndex state;
  597. # endif
  598. {
  599.   Automaton_tStateIndex RedState;
  600.   Automaton_tStateIndex maxState;
  601.   Automaton_tItemIndex item;
  602.   Automaton_tProduction prod;
  603.   Sets_tSet Look;
  604.   TokenTab_Terminal t;
  605.  
  606.   Sets_MakeSet(&Look, (LONGCARD)TokenTab_MAXTerm);
  607.   {
  608.     register Automaton_tState *W_9 = &Automaton_StateArrayPtr->A[state - 1];
  609.  
  610.     if (W_9->Kind == Automaton_sRead) {
  611.       {
  612.         LONGCARD B_19 = W_9->Items, B_20 = W_9->Items + W_9->Size - 1;
  613.  
  614.         if (B_19 <= B_20)
  615.           for (item = B_19;; item += 1) {
  616.             {
  617.               register Automaton_tItem *W_10 = &Automaton_ItemArrayPtr->A[item - 1];
  618.  
  619.               switch (W_10->Rep) {
  620.               case Automaton_TermRep:;
  621.                 TableLine.A[W_10->Read] = Automaton_StateArrayPtr->A[W_10->Next - 1].NewNumber;
  622.                 break;
  623.               case Automaton_NonTermRep:;
  624.                 TableLine.A[W_10->Read - Gen_NonTermOffset] = Automaton_StateArrayPtr->A[W_10->Next - 1].NewNumber;
  625.                 break;
  626.               case Automaton_RedRep:;
  627.                 prod = (Automaton_tProduction)ADR(Automaton_ProdArrayPtr->A[W_10->Prod]);
  628.                 RedState = Gen_ReduceOffset + prod->ProdNo;
  629.                 Sets_Assign(&Look, W_10->Set);
  630.                 while (!Sets_IsEmpty(Look)) {
  631.                   t = Sets_Extract(&Look);
  632.                   TableLine.A[t] = RedState;
  633.                 }
  634.                 break;
  635.               default :
  636.                 break;
  637.               }
  638.             }
  639.             if (item >= B_20) break;
  640.           }
  641.       }
  642.     }
  643.     Sets_ReleaseSet(&Look);
  644.     return W_9->NewNumber;
  645.   }
  646. }
  647.  
  648. static void MakeLength
  649. # ifdef __STDC__
  650. ()
  651. # else
  652. ()
  653. # endif
  654. {
  655.   Automaton_tProduction prod;
  656.   Automaton_tProdIndex index, prodno;
  657.  
  658.   Gen_LengthCount = Automaton_ProdCount;
  659.   DynArray_MakeArray((ADDRESS *)&Gen_Length, &Gen_LengthCount, (LONGINT)Gen_ElmtSize);
  660.   index = 0;
  661.   {
  662.     Automaton_tProdIndex B_21 = 1, B_22 = Automaton_ProdCount;
  663.  
  664.     if (B_21 <= B_22)
  665.       for (prodno = B_21;; prodno += 1) {
  666.         prod = (Automaton_tProduction)ADR(Automaton_ProdArrayPtr->A[index]);
  667.         Gen_Length->A[prodno - 1] = prod->Len;
  668.         index = Automaton_NextProdIndex(index);
  669.         if (prodno >= B_22) break;
  670.       }
  671.   }
  672. }
  673.  
  674. static void MakeLeftHandSide
  675. # ifdef __STDC__
  676. ()
  677. # else
  678. ()
  679. # endif
  680. {
  681.   Automaton_tProduction prod;
  682.   Automaton_tProdIndex index, prodno;
  683.  
  684.   Gen_LeftHandSideCount = Automaton_ProdCount;
  685.   DynArray_MakeArray((ADDRESS *)&Gen_LeftHandSide, &Gen_LeftHandSideCount, (LONGINT)Gen_ElmtSize);
  686.   index = 0;
  687.   {
  688.     Automaton_tProdIndex B_23 = 1, B_24 = Automaton_ProdCount;
  689.  
  690.     if (B_23 <= B_24)
  691.       for (prodno = B_23;; prodno += 1) {
  692.         prod = (Automaton_tProduction)ADR(Automaton_ProdArrayPtr->A[index]);
  693.         Gen_LeftHandSide->A[prodno - 1] = prod->Left - Gen_NonTermOffset;
  694.         index = Automaton_NextProdIndex(index);
  695.         if (prodno >= B_24) break;
  696.       }
  697.   }
  698. }
  699.  
  700. static TokenTab_Vocabulary FindFirstTerminal
  701. # ifdef __STDC__
  702. ()
  703. # else
  704. ()
  705. # endif
  706. {
  707.   return 0;
  708. }
  709.  
  710. static TokenTab_Vocabulary FindLastTerminal
  711. # ifdef __STDC__
  712. ()
  713. # else
  714. ()
  715. # endif
  716. {
  717.   TokenTab_Vocabulary sym;
  718.  
  719.   sym = TokenTab_MAXTerm;
  720.   for (;;) {
  721.     if (TokenTab_GetTokenType(sym) == TokenTab_Term) {
  722.       return sym;
  723.     }
  724.     DEC(sym);
  725.   } EXIT_1:;
  726. }
  727.  
  728. static TokenTab_Vocabulary FindLastSymbol
  729. # ifdef __STDC__
  730. ()
  731. # else
  732. ()
  733. # endif
  734. {
  735.   TokenTab_Vocabulary sym;
  736.  
  737.   sym = TokenTab_MAXNonTerm;
  738.   for (;;) {
  739.     if (TokenTab_GetTokenType(sym) != TokenTab_None) {
  740.       return sym;
  741.     }
  742.     DEC(sym);
  743.   } EXIT_2:;
  744. }
  745.  
  746. CARDINAL Gen_StartState
  747. # ifdef __STDC__
  748. ()
  749. # else
  750. ()
  751. # endif
  752. {
  753.   return Automaton_StateArrayPtr->A[1 - 1].NewNumber;
  754. }
  755.  
  756. static void PrepareReduceCode
  757. # ifdef __STDC__
  758. ()
  759. # else
  760. ()
  761. # endif
  762. {
  763.   Automaton_tProdIndex index;
  764.   Automaton_tProduction prod;
  765.   Automaton_tStateIndex maxState, state;
  766.   Automaton_tProdIndex maxProdIndex;
  767.   LONGINT u;
  768.   Automaton_tItemIndex item;
  769.  
  770.   index = 0;
  771.   state = Gen_ReduceOffset;
  772.   maxProdIndex = Automaton_ProdIndex;
  773.   while (index < maxProdIndex) {
  774.     INC(state);
  775.     prod = (Automaton_tProduction)ADR(Automaton_ProdArrayPtr->A[index]);
  776.     {
  777.       register Automaton_tIndexList *W_11 = &prod->Reduce;
  778.  
  779.       W_11->Count = InitReduceCount;
  780.       DynArray_MakeArray((ADDRESS *)&W_11->Array, &W_11->Count, (LONGINT)sizeof(Automaton_tIndex));
  781.       W_11->Used = 1;
  782.       W_11->Array->A[1 - 1] = state;
  783.     }
  784.     index = Automaton_NextProdIndex(index);
  785.   }
  786.   maxState = Automaton_StateIndex;
  787.   {
  788.     Automaton_tStateIndex B_25 = 1, B_26 = maxState;
  789.  
  790.     if (B_25 <= B_26)
  791.       for (state = B_25;; state += 1) {
  792.         {
  793.           register Automaton_tState *W_12 = &Automaton_StateArrayPtr->A[state - 1];
  794.  
  795.           if (W_12->Kind == Automaton_sTerm || W_12->Kind == Automaton_sNonterm) {
  796.             item = W_12->Items;
  797.             for (;;) {
  798.               if (Automaton_ItemArrayPtr->A[item - 1].Rep != Automaton_NoRep) {
  799.                 goto EXIT_3;
  800.               }
  801.               INC(item);
  802.             } EXIT_3:;
  803.             if (W_12->NewNumber <= Gen_ReduceOffset) {
  804.               index = Automaton_ItemArrayPtr->A[item - 1].Prod;
  805.               prod = (Automaton_tProduction)ADR(Automaton_ProdArrayPtr->A[index]);
  806.               {
  807.                 register Automaton_tIndexList *W_13 = &prod->Reduce;
  808.  
  809.                 INC(W_13->Used);
  810.                 if (W_13->Used > W_13->Count) {
  811.                   DynArray_ExtendArray((ADDRESS *)&W_13->Array, &W_13->Count, (LONGINT)sizeof(Automaton_tIndex));
  812.                 }
  813.                 W_13->Array->A[W_13->Used - 1] = W_12->NewNumber;
  814.               }
  815.             }
  816.           }
  817.         }
  818.         if (state >= B_26) break;
  819.       }
  820.   }
  821. }
  822.  
  823. static void PutTable
  824. # ifdef __STDC__
  825. (Gen_TableElmt Length, ADDRESS Address)
  826. # else
  827. (Length, Address)
  828. Gen_TableElmt Length;
  829. ADDRESS Address;
  830. # endif
  831. {
  832.   INTEGER N;
  833.   Strings_tString string;
  834.  
  835.   N = Write(*G_2_TableFile, ADR(Length), (LONGCARD)Gen_ElmtSize);
  836.   if (SysError_StatIsBad(N)) {
  837.     Strings_ArrayToString(FileName.A, 129L, &string);
  838.     SysError_SysErrorMessageI(N, (LONGCARD)Errors_eError, (LONGCARD)Errors_eString, ADR(string));
  839.     *G_1_InError = TRUE;
  840.     return;
  841.   }
  842.   N = Write(*G_2_TableFile, Address, (LONGCARD)Length);
  843.   if (SysError_StatIsBad(N)) {
  844.     Strings_ArrayToString(FileName.A, 129L, &string);
  845.     SysError_SysErrorMessageI(N, (LONGCARD)Errors_eError, (LONGCARD)Errors_eString, ADR(string));
  846.     *G_1_InError = TRUE;
  847.     return;
  848.   }
  849. }
  850.  
  851. static void PutTables
  852. # ifdef __STDC__
  853. (System_tFile TableFile)
  854. # else
  855. (TableFile)
  856. System_tFile TableFile;
  857. # endif
  858. {
  859.   BOOLEAN InError;
  860.   CARDINAL BlockSize, i;
  861.   BOOLEAN *L_1;
  862.   System_tFile *L_2;
  863.  
  864.   L_1 = G_1_InError;
  865.   G_1_InError = &InError;
  866.   L_2 = G_2_TableFile;
  867.   G_2_TableFile = &TableFile;
  868.   BlockSize = 64000 / sizeof(ControlType);
  869.   InError = FALSE;
  870.   PutTable((Gen_LastReadState + 1) * Gen_ElmtSize, (ADDRESS)Compress_Base);
  871.   if (InError) {
  872.     G_1_InError = L_1;
  873.     G_2_TableFile = L_2;
  874.     return;
  875.   }
  876.   PutTable((Gen_LastReadState + 1) * Gen_ElmtSize, (ADDRESS)Compress_NBase);
  877.   if (InError) {
  878.     G_1_InError = L_1;
  879.     G_2_TableFile = L_2;
  880.     return;
  881.   }
  882.   PutTable((Gen_LastReadState + 1) * Gen_ElmtSize, (ADDRESS)Compress_Default);
  883.   if (InError) {
  884.     G_1_InError = L_1;
  885.     G_2_TableFile = L_2;
  886.     return;
  887.   }
  888.   PutTable((SHORTCARD)((Compress_NTableSize - Gen_LastTerminal) * sizeof(Gen_TableElmt)), ADR(Compress_NNext->A[Gen_LastTerminal + 1]));
  889.   if (InError) {
  890.     G_1_InError = L_1;
  891.     G_2_TableFile = L_2;
  892.     return;
  893.   }
  894.   PutTable((Gen_LastReduceState - Gen_FirstReduceState + 1) * Gen_ElmtSize, (ADDRESS)Gen_Length);
  895.   if (InError) {
  896.     G_1_InError = L_1;
  897.     G_2_TableFile = L_2;
  898.     return;
  899.   }
  900.   PutTable((Gen_LastReduceState - Gen_FirstReduceState + 1) * Gen_ElmtSize, (ADDRESS)Gen_LeftHandSide);
  901.   if (InError) {
  902.     G_1_InError = L_1;
  903.     G_2_TableFile = L_2;
  904.     return;
  905.   }
  906.   PutTable((Gen_LastReadState + 1) * Gen_ElmtSize, (ADDRESS)Gen_Continuation);
  907.   if (InError) {
  908.     G_1_InError = L_1;
  909.     G_2_TableFile = L_2;
  910.     return;
  911.   }
  912.   PutTable((Gen_LastReadNonTermState - Gen_FirstReadTermState + 1) * Gen_ElmtSize, (ADDRESS)Gen_FinalToProd);
  913.   if (InError) {
  914.     G_1_InError = L_1;
  915.     G_2_TableFile = L_2;
  916.     return;
  917.   }
  918.   i = 0;
  919.   while (i <= Compress_TableSize) {
  920.     PutTable((SHORTCARD)(General_Min((LONGINT)BlockSize, (LONGINT)(Compress_TableSize + 1 - i)) * sizeof(ControlType)), ADR(Compress_Control->A[i]));
  921.     if (InError) {
  922.       G_1_InError = L_1;
  923.       G_2_TableFile = L_2;
  924.       return;
  925.     }
  926.     INC1(i, BlockSize);
  927.   }
  928.   G_1_InError = L_1;
  929.   G_2_TableFile = L_2;
  930. }
  931.  
  932. static void PutBase
  933. # ifdef __STDC__
  934. (System_tFile File)
  935. # else
  936. (File)
  937. System_tFile File;
  938. # endif
  939. {
  940.   Automaton_tStateIndex i;
  941.  
  942.   {
  943.     Automaton_tStateIndex B_27 = 0, B_28 = Gen_LastReadState;
  944.  
  945.     if (B_27 <= B_28)
  946.       for (i = B_27;; i += 1) {
  947.         IO_WriteS(File, (STRING)"& yyTComb [", 11L);
  948.         IO_WriteI(File, (LONGINT)Compress_Base->A[i], 0L);
  949.         IO_WriteS(File, (STRING)"],", 2L);
  950.         IO_WriteNl(File);
  951.         if (i >= B_28) break;
  952.       }
  953.   }
  954. }
  955.  
  956. static void PutNBase
  957. # ifdef __STDC__
  958. (System_tFile File)
  959. # else
  960. (File)
  961. System_tFile File;
  962. # endif
  963. {
  964.   Automaton_tStateIndex i;
  965.  
  966.   {
  967.     Automaton_tStateIndex B_29 = 0, B_30 = Gen_LastReadState;
  968.  
  969.     if (B_29 <= B_30)
  970.       for (i = B_29;; i += 1) {
  971.         IO_WriteS(File, (STRING)"& yyNComb [", 11L);
  972.         IO_WriteI(File, (LONGINT)((SHORTINT)Compress_NBase->A[i] - (SHORTINT)Gen_LastTerminal - 1), 0L);
  973.         IO_WriteS(File, (STRING)"],", 2L);
  974.         IO_WriteNl(File);
  975.         if (i >= B_30) break;
  976.       }
  977.   }
  978. }
  979.  
  980. static void PutDefault
  981. # ifdef __STDC__
  982. (System_tFile File)
  983. # else
  984. (File)
  985. System_tFile File;
  986. # endif
  987. {
  988.   Automaton_tStateIndex i;
  989.  
  990.   {
  991.     Automaton_tStateIndex B_31 = 0, B_32 = Gen_LastReadState;
  992.  
  993.     if (B_31 <= B_32)
  994.       for (i = B_31;; i += 1) {
  995.         IO_WriteI(File, (LONGINT)Compress_Default->A[i], 0L);
  996.         IO_WriteC(File, ',');
  997.         IO_WriteNl(File);
  998.         if (i >= B_32) break;
  999.       }
  1000.   }
  1001. }
  1002.  
  1003. static void PutControl
  1004. # ifdef __STDC__
  1005. (System_tFile File)
  1006. # else
  1007. (File)
  1008. System_tFile File;
  1009. # endif
  1010. {
  1011.   CARDINAL i;
  1012.  
  1013.   {
  1014.     LONGCARD B_33 = 0, B_34 = Compress_TableSize;
  1015.  
  1016.     if (B_33 <= B_34)
  1017.       for (i = B_33;; i += 1) {
  1018.         IO_WriteC(File, '{');
  1019.         IO_WriteI(File, (LONGINT)Compress_Control->A[i].Check, 0L);
  1020.         IO_WriteS(File, (STRING)", ", 2L);
  1021.         IO_WriteI(File, (LONGINT)Compress_Control->A[i].Next, 0L);
  1022.         IO_WriteS(File, (STRING)"},", 2L);
  1023.         IO_WriteNl(File);
  1024.         if (i >= B_34) break;
  1025.       }
  1026.   }
  1027. }
  1028.  
  1029. static void PutNNext
  1030. # ifdef __STDC__
  1031. (System_tFile File)
  1032. # else
  1033. (File)
  1034. System_tFile File;
  1035. # endif
  1036. {
  1037.   Automaton_tStateIndex i;
  1038.  
  1039.   {
  1040.     Automaton_tStateIndex B_35 = Gen_LastTerminal + 1, B_36 = Compress_NTableSize;
  1041.  
  1042.     if (B_35 <= B_36)
  1043.       for (i = B_35;; i += 1) {
  1044.         IO_WriteI(File, (LONGINT)Compress_NNext->A[i], 0L);
  1045.         IO_WriteC(File, ',');
  1046.         IO_WriteNl(File);
  1047.         if (i >= B_36) break;
  1048.       }
  1049.   }
  1050. }
  1051.  
  1052. static void PutLength
  1053. # ifdef __STDC__
  1054. (System_tFile File)
  1055. # else
  1056. (File)
  1057. System_tFile File;
  1058. # endif
  1059. {
  1060.   Automaton_tStateIndex i;
  1061.  
  1062.   {
  1063.     Automaton_tStateIndex B_37 = 1, B_38 = Automaton_ProdCount;
  1064.  
  1065.     if (B_37 <= B_38)
  1066.       for (i = B_37;; i += 1) {
  1067.         IO_WriteI(File, (LONGINT)Gen_Length->A[i - 1], 0L);
  1068.         IO_WriteC(File, ',');
  1069.         IO_WriteNl(File);
  1070.         if (i >= B_38) break;
  1071.       }
  1072.   }
  1073. }
  1074.  
  1075. static void PutLeftHandSide
  1076. # ifdef __STDC__
  1077. (System_tFile File)
  1078. # else
  1079. (File)
  1080. System_tFile File;
  1081. # endif
  1082. {
  1083.   Automaton_tStateIndex i;
  1084.  
  1085.   {
  1086.     Automaton_tStateIndex B_39 = 1, B_40 = Automaton_ProdCount;
  1087.  
  1088.     if (B_39 <= B_40)
  1089.       for (i = B_39;; i += 1) {
  1090.         IO_WriteI(File, (LONGINT)Gen_LeftHandSide->A[i - 1], 0L);
  1091.         IO_WriteC(File, ',');
  1092.         IO_WriteNl(File);
  1093.         if (i >= B_40) break;
  1094.       }
  1095.   }
  1096. }
  1097.  
  1098. static void PutContinuation
  1099. # ifdef __STDC__
  1100. (System_tFile File)
  1101. # else
  1102. (File)
  1103. System_tFile File;
  1104. # endif
  1105. {
  1106.   Automaton_tStateIndex i;
  1107.  
  1108.   {
  1109.     Automaton_tStateIndex B_41 = 0, B_42 = Gen_LastReadState;
  1110.  
  1111.     if (B_41 <= B_42)
  1112.       for (i = B_41;; i += 1) {
  1113.         IO_WriteI(File, (LONGINT)Gen_Continuation->A[i], 0L);
  1114.         IO_WriteC(File, ',');
  1115.         IO_WriteNl(File);
  1116.         if (i >= B_42) break;
  1117.       }
  1118.   }
  1119. }
  1120.  
  1121. static void PutFinalToProd
  1122. # ifdef __STDC__
  1123. (System_tFile File)
  1124. # else
  1125. (File)
  1126. System_tFile File;
  1127. # endif
  1128. {
  1129.   Automaton_tStateIndex i;
  1130.  
  1131.   {
  1132.     Automaton_tStateIndex B_43 = Gen_FirstReadTermState, B_44 = Gen_LastReadNonTermState;
  1133.  
  1134.     if (B_43 <= B_44)
  1135.       for (i = B_43;; i += 1) {
  1136.         IO_WriteI(File, (LONGINT)Gen_FinalToProd->A[i - Gen_FirstReadTermState], 0L);
  1137.         IO_WriteC(File, ',');
  1138.         IO_WriteNl(File);
  1139.         if (i >= B_44) break;
  1140.       }
  1141.   }
  1142. }
  1143.  
  1144. void BEGIN_Gen()
  1145. {
  1146.   static BOOLEAN has_been_called = FALSE;
  1147.  
  1148.   if (!has_been_called) {
  1149.     has_been_called = TRUE;
  1150.  
  1151.     BEGIN_TokenTab();
  1152.     BEGIN_Automaton();
  1153.     BEGIN_IO();
  1154.     BEGIN_TokenTab();
  1155.     BEGIN_Actions();
  1156.     BEGIN_ArgCheck();
  1157.     BEGIN_Automaton();
  1158.     BEGIN_Compress();
  1159.     BEGIN_Continue();
  1160.     BEGIN_Checks();
  1161.     BEGIN_Default();
  1162.     BEGIN_DynArray();
  1163.     BEGIN_Errors();
  1164.     BEGIN_Final();
  1165.     BEGIN_General();
  1166.     BEGIN_GenLang();
  1167.     BEGIN_IO();
  1168.     BEGIN_Lists();
  1169.     BEGIN_Lists();
  1170.     BEGIN_Sets();
  1171.     BEGIN_Strings();
  1172.     BEGIN_StringMem();
  1173.     BEGIN_Strings();
  1174.     BEGIN_Idents();
  1175.     BEGIN_SysError();
  1176.     BEGIN_System();
  1177.     BEGIN_System();
  1178.     BEGIN_Times();
  1179.     BEGIN_TokenTab();
  1180.     BEGIN_WriteTok();
  1181.  
  1182.     Gen_ElmtSize = sizeof(Gen_TableElmt);
  1183.     Gen_Trace = FALSE;
  1184.     Gen_CaseFlag = FALSE;
  1185.   }
  1186. }
  1187.